Run-time monitoring and on-line testing of middleware based communication services

With the present day's exponential growth of the (tele-)communications market, the explosion of the number of mobile communication customers, and the tremendous growth of the number of IP hosts, ensuring the reliability of communication services is one of the most challenging tasks in today's software engineering. This Thesis addresses this problem by providing a new method for increasing confidence in the implementation of communication services. We developed an approach for monitoring and testing communications services that are built on top of a middleware. Specifically, we show how to monitor a communication service and how to use the monitored information to test at runtime whether the behavior of the service conforms to constraints. The constraints are extracted from the requirements, expressed using a formal method. The approach advocated in this Thesis consists in combining the power of formal methods, which have reached a high degree of maturity in the academic domain, with a testing methodology, that fit the industrial needs, in order to test the implementation of a communication service. The developer can thus focus on the testing rather then on how the testing is performed. To solve this problem (1) we designed a monitoring mechanism that is able to observe at run-time, the events occuring in the system under scrutiny, (2) designed a testing mechanism that checks at runtime if properties expressed using Temporal Logic, are violated by the execution of the application, (3) implemented a prototype tool, MOTEL (MOnitoring and TEsting tooL). With our approach the tester need only to specify the properties. The other steps involved in the testing processes are performed automatically. According to the content of the properties the instrumentation is added in the system to be tested. This instrumentation reports a consistent order of the events occurring to a central Observer. Within this Observer, the properties, which are independent of the implementation language, are translated into deterministic automata. At run-time these automata are used, according to the events reported by the instrumentation to the Observer, to check if the properties are violated. Thus, our monitoring and testing mechanism fits well in the development process because it does not add noticeable new steps for the developer. In this thesis we put together many concepts and solutions from various domains (distributed systems, middleware, object-oriented development, CORBA, communication services, formal method, Temporal Logic, automata theory, monitoring, testing). By enhancing, developing and combining, and integrating them together, we reached a high level of integration that provides a new, powerful and useful functionality to test the implementation of communication services. We believe that there is not a more valuable argument for the application and practical relevance of our approach in the industry, than the introduction and use of our method and tool in and by the industry. Our partner, Alcatel, is currently integrating MOTEL in the distributed platform PERCO

Testing Temporal Logic Properties in Distributed Systems

The concept of event-based behavioral abstraction (EBBA) is shown to facilitate the Design For Testability (DFT) if the set of events is well-chosen. We provide a predefined set of events which, together with linear-time temporal logic, can be used for expressing behavioral properties in object-oriented distributed systems. This allows automizing several steps in the testing process: instrumenting the source code, constructing test-oracles and generating an observer. Taking an industrial example as basis, we discuss how our proposal can be integrated into the software design- and testing process

TINA Service Validation: The ErnesTINA Project

While extensive work has been carried out with the goal of validating the TINA architecture and the TINA documents, little has been done yet for the validation of TINA services. This is the main focus of the ErnesTINA project. In the ErnesTINA project, we propose an integrated approach to facilitate the validation of TINA services by verifying at run-time that the service implementation has not violated and is not violating certain predefined properties. In this paper, we present the specification of the properties, the run-time observation of the distributed environment, the validation of the properties and finally the implementation of the concepts in a prototype

Modelling and Testing Object-Oriented Distributed Systems with Linear-time Temporal Logic

Numerous proposals for applying temporal logic to the specification and verification of object-oriented systems have appeared in the past several years. Although various temporal models have been proposed for the requirements analysis of object-oriented distributed systems, there is no similar amount of work for the design- and implementation phase. We present a formal model for the design- and implementation stage which reflects practical requirements and is yet sufficiently general to be applied to a wide range of systems. In our model, which relies on event-based behavioral abstraction, we use linear-time temporal logic as the underlying formalism for the specification of behavioral constraints. We show that although temporal logic is a powerful tool for behavior specifications, it does not have the expressive power required for non-trivial object systems. Specifically, in an object-system it is often essential to express procedural dependencies rather than simple temporal relationships for which we introduce two novel operators. In a case study we demonstrate the practical relevance and applicability of our model

On Applying Formal Techniques to the Development of Hybrid Services: Challenges and Directions

We are primarily interested in formal techniques and how they are applied to the development of hybrid services in particular. We analyze the peculiarities of such services, we look at the use of formal techniques for communication services in the industry and highlight some of the major concerns for the application of formality in an industrial environment. It is argued that with the introduction of hybrid services, more pragmatism is required in applying formal techniques. We briefly describe an ongoing joint collaboration with Alcatel, Swisscom and the Swiss Federal Institute of Technology in which formal techniques are applied to the specification and testing of hybrid services

Improving Confidence in Service Implementation in an Intelligent Network

The approach to improve confidence in Services Implementation presented in this paper is based on the addition of a Service Modeler and Verifier Function (SMV) in the environment where the service take place. The SMV, combined with a test scenario, is able to detect on-the-fly implementations errors. The SMV keeps an abstract model of the service and the environment in which the service is executed and verifies at each model change properties derived from the requirements. In order to update its model the SMV spies all messages between the different entities of the network. The properties are expresses in linear time temporal logic. This paper presents the concept of the SMV and its realization for the CS-1 Intelligent Network

Teleteaching over Broadband Networks: The BETEUS project

In this paper, we present the design and implementation of the Beteus (Broadband Exchange for Trans-European Usage) communication platform. BETEUS is an european project aiming at developing a generic, stable, flexible and scalable communication platform which provides support for interactive work between distributed end-users. In terms of interactive work, BETEUS concentrates on distributed classrooms, tele-seminars, multimedia document archival and retrieval and tele-tutoring. The problems raised during the realization of the BETEUS communication platform are outlined and the proposed solutions explained. The follow-up of BETEUS in Switzerland through the TELEPOLY project which concerns operational teleteaching between the two Swiss federal institutes of technology (EPFL and ETHZ) is also presented

Run-time monitoring of distributed applications

n this paper we present a method to perform run-time monitoring of distributed applications built on top of a distributed object oriented processing environment. For this, we instrument the code at the compilation time in order to send notifications to an Observer when relevant events occur in the system, the instrumentation is done in an automated manner, requiring a minimum of programmer interactions. One advantage of our run-time monitoring approach is that it does not hinder the development process already adopted. In our proposal, the choice of the information to select for observation is made simple by the definition of events which are generic and useful for all distributed applications, the user does not need to specify them. We apply our run-time monitoring method to a telecommunication services implemented on top of the distributed processing environment CORBA Orbix from IONA